#include "direccionamiento_FAT.h"

/*____________________________________________________*/

int convertir_Pedido(int numBloque) {

	int numSectorIni;
	int distancia = 1;
	numSectorIni = numBloque+numBloque * distancia;

	return numSectorIni;

}

/*____________________________________________________*/

int realizar_pedido_lectura(int numBloque, char* datos){
	int i,sock;
	char buffer[1200];
	memset(buffer,0,1200);
	NIPC pack,pack2;
	down(semSock);

	down(mutexSock);
	for(i=0;i<cantConexiones;i++)
		if(vectorSocket[i]!=0)
			break;

	sock=vectorSocket[i];
	vectorSocket[i]=0;
	up(mutexSock);
	uint32_t sectorIni;

	sectorIni=convertir_Pedido(numBloque);
	pack.mensaje=malloc(sizeof (uint32_t));
	pack2.mensaje=malloc(sizeof (uint32_t));
	char miniV[sizeof(uint32_t)];
	memset(miniV,0,sizeof(uint32_t));
	memcpy(miniV,&sectorIni,sizeof(uint32_t));
	cargarEstructura(&pack,1,miniV);
	sectorIni++;
	memset(miniV,0,sizeof(uint32_t));
	memcpy(miniV,&sectorIni,sizeof(uint32_t));
	cargarEstructura(&pack2,2,miniV);
	char vector[pack.payloadLength+3];
	char vector2[pack2.payloadLength+3];

	serializar_NIPC(pack,vector);
	serializar_NIPC(pack2,vector2);
	enviarDatos(vector,pack.payloadLength+3,sock);
	enviarDatos(vector2,pack2.payloadLength+3,sock);
	int resultado=0; int res=0;
	while( resultado<1000&&res>0) {
		res=recv(sock,buffer+res,1200,0);
	resultado+=res;
	}
	down(mutexSock);
	vectorSocket[i]=sock;
	up(mutexSock);
	up(semSock);

	parsearResultadoLectura(buffer,datos);
	free(pack.mensaje);
	free(pack2.mensaje);
	return 0;
}

/*____________________________________________________*/

int realizar_pedido_escritura(int numBloque, char* datos){
	int i,sock;
		char buffer[1200];
		memset(buffer,0,1200);
		NIPC pack,pack2;
		down(semSock);

		down(mutexSock);
		for(i=0;i<cantConexiones;i++)
			if(vectorSocket[i]!=0)
				break;

		sock=vectorSocket[i];
		vectorSocket[i]=0;
		up(mutexSock);
		uint32_t sectorIni;

		sectorIni=convertir_Pedido(numBloque);
		pack.mensaje=malloc(sizeof (uint32_t));
		pack2.mensaje=malloc(sizeof (uint32_t));
		char miniV[sizeof(uint32_t)];
		memset(miniV,0,sizeof(uint32_t));
		memcpy(miniV,&sectorIni,sizeof(uint32_t));
		cargarEstructura(&pack,1,miniV);
		sectorIni++;
		memset(miniV,0,sizeof(uint32_t));
		memcpy(miniV,&sectorIni,sizeof(uint32_t));
		cargarEstructura(&pack2,2,miniV);
		char vector[pack.payloadLength+3];
		char vector2[pack2.payloadLength+3];
		serializar_NIPC(pack,vector);
		serializar_NIPC(pack2,vector2);
		enviarDatos(vector,pack.payloadLength+3,sock);
		enviarDatos(vector2,pack2.payloadLength+3,sock);
		int resultado=0; int res=0;
		while( resultado<6&&res>0) {
			res=recv(sock,buffer+res,1200,0);
		resultado+=res;
		}
		down(mutexSock);
		vectorSocket[i]=sock;
		up(mutexSock);
		up(semSock);


		parsearResultadoEscritura(buffer);
		free(pack.mensaje);
		free(pack2.mensaje);
		return 0;

	return 0;
}

/*____________________________________________________*/

int parsearResultadoLectura(char*buffer,char*datos){

	int id,id2,lon;
	memcpy(&lon,buffer+1,sizeof(uint16_t));
	memcpy(&id,buffer,sizeof(uint8_t));
	if(id==1)
		memcpy(datos,buffer+3,lon);
	else if(id==2)
		memcpy(datos+512,buffer+3,lon);
	else
		return 1;
	memcpy(&lon,buffer+1+lon,sizeof(uint16_t));
	memcpy(&id2,buffer+lon,sizeof(uint8_t));
	if(id2==id)
		return 1;
	else{
		if(id2==1)
			memcpy(datos,buffer+3,lon);
		else if(id2==2)
			memcpy(datos+512,buffer+3,lon);
		else
			return 1;

	}

	return 0;
}

int parsearResultadoEscritura(char*buffer){
	int id,id2,lon;
	memcpy(&lon,buffer+1,sizeof(uint16_t));
	memcpy(&id,buffer,sizeof(uint8_t));
	if((id!=3&&id!=4)||lon!=0)
		return 1;
		else{
			memcpy(&lon,buffer+1+lon,sizeof(uint16_t));
			memcpy(&id2,buffer+lon,sizeof(uint8_t));
			if(((id2!=3&&id2!=4)||lon!=0)||id2==id)
				return 1;
			else
				return 0;
		}

}
